package com.sg.service.biz.app.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.BatchQueryExecuteProgressReq;
import com.sg.dto.base.app.req.ImplementHoverExecuteProgressReq;
import com.sg.dto.base.app.req.QueryExecuteProgressDetailReq;
import com.sg.dto.base.app.req.QueryExecuteProgressListReq;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.component.ObtainProgressLoadingBgComReqDto;
import com.sg.dto.integration.component.ObtainProgressLoadingBgComRespDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComReqDto;
import com.sg.dto.integration.component.QueryConfItemMatchAnswerDetailComRespDto;
import com.sg.entity.OmsExecuteProgress;
import com.sg.service.base.app.MOmsEvaBatchRelatedSetService;
import com.sg.service.base.app.MOmsEvaluationObjectTargetCycleService;
import com.sg.service.base.app.MOmsExecuteProgressService;
import com.sg.service.base.app.MOmsTargetObjectiveService;
import com.sg.service.biz.app.InterfaceModeService;
import com.sg.service.biz.app.nb.NbExecuteProgress;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.TemplateEngineService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;


/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class ExecuteProgressServiceImpl
        implements com.wicket.okrapp.biz.service.ExecuteProgressService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsExecuteProgressService mOmsExecuteProgressService;
    @Resource
    private NbExecuteProgress nbExecuteProgress;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private TemplateEngineService fwCompTemplateEngineClient;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private MOmsTargetObjectiveService mOmsTargetObjectiveService;

    /**
     * D3执行分析进度值匹配进度范围(公共)[6967]
     * gen by moon at 7/3/2023, 12:22:07 PM
     */
    @Trace(operationName = "D3执行分析进度值匹配进度范围(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseProgressMatchScopeComRespDto implementAnalyseProgressMatchScopeCom(ImplementAnalyseProgressMatchScopeComReqDto reqDto) {


        ImplementGainInParameterFieldsRespDto receptionServiceRes_3 = null;
        if ((reqDto != null && reqDto.getExecuteProgressValue() >= 0 && reqDto != null && reqDto.getExecuteProgressValue() < 20)) {
            //if((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 0 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 20))  43191

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq.setCustomField("0");//CUSTOM_CONVENTION//sourceId:985993_1_43192

            /*M3约定进度：0[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：0-自定义字段不能为空", false);
            receptionServiceRes = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_2 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_1 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setCustomField(receptionServiceRes.getCustomField());//SimpleFieldAssign//sourceId:986096_1_43204
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_2 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 20 && reqDto != null && reqDto.getExecuteProgressValue() < 30)) {
            //elseif((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 20 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 30))  43193

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_4 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_2 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_2.setCustomField("20");//CUSTOM_CONVENTION//sourceId:985996_1_43194

            /*M3约定进度：20[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：20-自定义字段不能为空", false);
            receptionServiceRes_4 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_2);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_6 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_3 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_4 != null) {
                receptionServiceReq_3.setCustomField(receptionServiceRes_4.getCustomField());//SimpleFieldAssign//sourceId:986096_1_43206
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_6 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_6;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 30 && reqDto != null && reqDto.getExecuteProgressValue() < 50)) {
            //elseif((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 30 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 50))  43195

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_7 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_4 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_4.setCustomField("30");//CUSTOM_CONVENTION//sourceId:985997_1_43196

            /*M3约定进度：30[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_4.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：30-自定义字段不能为空", false);
            receptionServiceRes_7 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_4);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_9 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_5 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_7 != null) {
                receptionServiceReq_5.setCustomField(receptionServiceRes_7.getCustomField());//SimpleFieldAssign//sourceId:986096_1_43207
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_9 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_5);


            receptionServiceRes_3 = receptionServiceRes_9;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 50 && reqDto != null && reqDto.getExecuteProgressValue() < 60)) {
            //elseif((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 50 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 60))  43197

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_10 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_6 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_6.setCustomField("50");//CUSTOM_CONVENTION//sourceId:986050_1_43198

            /*M3约定进度：50[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_6.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：50-自定义字段不能为空", false);
            receptionServiceRes_10 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_6);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_12 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_7 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_10 != null) {
                receptionServiceReq_7.setCustomField(receptionServiceRes_10.getCustomField());//SimpleFieldAssign//sourceId:986096_1_43208
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_7.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_12 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_7);


            receptionServiceRes_3 = receptionServiceRes_12;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 60 && reqDto != null && reqDto.getExecuteProgressValue() < 80)) {
            //elseif((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 60 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 80))  43199

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_13 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_8 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_8.setCustomField("60");//CUSTOM_CONVENTION//sourceId:986051_1_43200

            /*M3约定进度：60[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_8.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：60-自定义字段不能为空", false);
            receptionServiceRes_13 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_8);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_15 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_9 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_13 != null) {
                receptionServiceReq_9.setCustomField(receptionServiceRes_13.getCustomField());//SimpleFieldAssign//sourceId:986096_1_43209
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_9.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_15 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_9);


            receptionServiceRes_3 = receptionServiceRes_15;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 80 && reqDto != null && reqDto.getExecuteProgressValue() < 85)) {
            //elseif((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 80 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 85))  43201

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_16 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_10 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_10.setCustomField("80");//CUSTOM_CONVENTION//sourceId:986055_1_43202

            /*M3约定进度：80[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_10.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：80-自定义字段不能为空", false);
            receptionServiceRes_16 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_10);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_18 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_11 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_16 != null) {
                receptionServiceReq_11.setCustomField(receptionServiceRes_16.getCustomField());//SimpleFieldAssign//sourceId:986096_1_43210
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_11.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_18 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_11);


            receptionServiceRes_3 = receptionServiceRes_18;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 85 && reqDto != null && reqDto.getExecuteProgressValue() < 95)) {
            //elseif((D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 85 and D3执行分析进度值匹配进度范围(公共).执行进度值 小于 95))  46818

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_19 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_12 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_12.setCustomField("95");//CUSTOM_CONVENTION//sourceId:1075297_1_46820

            /*M3约定进度：95[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_12.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：95-自定义字段不能为空", false);
            receptionServiceRes_19 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_12);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_21 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_13 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_19 != null) {
                receptionServiceReq_13.setCustomField(receptionServiceRes_19.getCustomField());//SimpleFieldAssign//sourceId:986096_1_46819
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_13.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_21 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_13);


            receptionServiceRes_3 = receptionServiceRes_21;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() >= 95)) {
            //elseif(D3执行分析进度值匹配进度范围(公共).执行进度值 大于等于 95)  46821

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_22 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_14 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_14.setCustomField("100");//CUSTOM_CONVENTION//sourceId:1075332_1_46822

            /*M3约定进度：100[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_14.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3约定进度：100-自定义字段不能为空", false);
            receptionServiceRes_22 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_14);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_24 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_15 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_22 != null) {
                receptionServiceReq_15.setCustomField(receptionServiceRes_22.getCustomField());//SimpleFieldAssign//sourceId:986096_1_46823
            }

            /*M3接收上文出参值[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_15.getCustomField(), "D3执行分析进度值匹配进度范围(公共)-M3接收上文出参值-自定义字段不能为空", false);
            receptionServiceRes_24 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_15);


            receptionServiceRes_3 = receptionServiceRes_24;
        }
        ImplementAnalyseProgressMatchScopeComRespDto retData = new ImplementAnalyseProgressMatchScopeComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setCustomField(receptionServiceRes_3.getCustomField());//SimpleFieldAssign//sourceId:986105_1
        }


        return retData;
    }

    /**
     * D3更新执行周期执行进度处理进度(公共)[6963]
     * gen by moon at 5/29/2023, 2:23:19 PM
     */
    @Trace(operationName = "D3更新执行周期执行进度处理进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RefreshExecuteProgressDisposeComRespDto refreshExecuteProgressDisposeCom(RefreshExecuteProgressDisposeComReqDto reqDto) {


        //virtualUsage 3-15-01查执行进度详情  43381
        OmsExecuteProgress omsExecuteProgress = null;
        QueryExecuteProgressDetailReq queryExecuteProgressDetailReq = new QueryExecuteProgressDetailReq();
        if (reqDto != null) {
            queryExecuteProgressDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:985803_1_43381
            queryExecuteProgressDetailReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:985804_1_43381
            queryExecuteProgressDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:985805_1_43381
        }

        /*3-15-01查执行进度详情[6959]   */
        Assert.isNull(queryExecuteProgressDetailReq.getObjectId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01查执行进度详情-归属对象内容ID不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getUseTypeCode(), "D3更新执行周期执行进度处理进度(公共)-3-15-01查执行进度详情-用途类型编码不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getThemeContentId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01查执行进度详情-主题内容ID不能为空", false);
        omsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        //virtualUsage M3异步开始  43158
        //ModelCode: asynchronizationStart

        OmsExecuteProgress finalOmsExecuteProgress = omsExecuteProgress;
        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {

                //执行方法
//virtualUsage M3业务应用公共字段推送内存  43160
                //ModelCode: publicFieldCache
                ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
                if (finalOmsExecuteProgress != null) {
                    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
                    if (finalOmsExecuteProgress != null) {
                        publicFieldCacheReq.setCreateInductionId(finalOmsExecuteProgress.getCreateInductionId());//SimpleFieldAssign//sourceId:985787_1_43160
                        publicFieldCacheReq.setSpaceId(finalOmsExecuteProgress.getSpaceId());//SimpleFieldAssign//sourceId:985788_1_43160
                        publicFieldCacheReq.setAppId(finalOmsExecuteProgress.getAppId());//SimpleFieldAssign//sourceId:985789_1_43160
                    }

                    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
                    Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "D3更新执行周期执行进度处理进度(公共)-M3业务应用公共字段推送内存-创建人就职记录ID 不能为空", false);
                    Assert.isNull(publicFieldCacheReq.getSpaceId(), "D3更新执行周期执行进度处理进度(公共)-M3业务应用公共字段推送内存-创建于空间ID不能为空", false);
                    Assert.isNull(publicFieldCacheReq.getAppId(), "D3更新执行周期执行进度处理进度(公共)-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空", false);
                    publicFieldCacheRes = nbExecuteProgress.implementBizPublicFieldPushMemory(publicFieldCacheReq);


                }
                if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("0") && finalOmsExecuteProgress != null && finalOmsExecuteProgress.getIsComplete() != null && finalOmsExecuteProgress.getIsComplete().equals("FALSE"))) {
                    //if((D3更新执行周期执行进度处理进度(公共).处理步骤 等于 0 and 3-15-01查执行进度详情.是否已完成 等于 否))  43162

                    OmsExecuteProgress omsExecuteProgress_2 = null;
                    if (finalOmsExecuteProgress != null) {
                        ImplementHoverExecuteProgressReq implementHoverExecuteProgressReq = new ImplementHoverExecuteProgressReq();
                        implementHoverExecuteProgressReq.setExecuteProgressValue(Double.valueOf(-1));//CUSTOM_CONVENTION//sourceId:985769_1_43163
                        if (finalOmsExecuteProgress != null) {
                            implementHoverExecuteProgressReq.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:987831_1_43163
                        }
                        if (reqDto != null) {
                            implementHoverExecuteProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990435_1_43163
                        }

                        /*3-15-01执行悬停执行进度（悬停-1）[6964]   */
                        Assert.isNull(implementHoverExecuteProgressReq.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停-1）-执行进度记录ID不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停-1）-执行进度值不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq.getThemeContentId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停-1）-主题内容ID不能为空", false);
                        omsExecuteProgress_2 = mOmsExecuteProgressService.implementHoverExecuteProgress(implementHoverExecuteProgressReq)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN;
                    if (omsExecuteProgress_2 != null) {
                        OmsExecuteProgress omsExecuteProgress_4 = new OmsExecuteProgress();
                        omsExecuteProgress_4.setIsComplete("FALSE");//sourceId:985811_1_43164
                        if (omsExecuteProgress_2 != null) {
                            omsExecuteProgress_4.setExecuteProgressId(omsExecuteProgress_2.getExecuteProgressId());//SimpleFieldAssign//sourceId:985809_1_43164
                        }
                        if (reqDto != null) {
                            omsExecuteProgress_4.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:985810_1_43164
                        }

                        /*3-15-01初始化执行进度值[6960]   */
                        Assert.isNull(omsExecuteProgress_4.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01初始化执行进度值-执行进度记录ID不能为空", false);
                        Assert.isNull(omsExecuteProgress_4.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01初始化执行进度值-执行进度值不能为空", false);
                        Assert.isNull(omsExecuteProgress_4.getIsComplete(), "D3更新执行周期执行进度处理进度(公共)-3-15-01初始化执行进度值-是否已完成不能为空", false);
                        bOOLEAN = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_4)/*vcase invoke 本地 method 方法调用;*/;


                    }
                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("1") && finalOmsExecuteProgress != null && finalOmsExecuteProgress.getIsComplete() != null && finalOmsExecuteProgress.getIsComplete().equals("FALSE"))) {
                    //elseif((D3更新执行周期执行进度处理进度(公共).处理步骤 等于 1 and 3-15-01查执行进度详情.是否已完成 等于 否))  43165

                    OmsExecuteProgress omsExecuteProgress_5 = null;
                    if (finalOmsExecuteProgress != null) {
                        ImplementHoverExecuteProgressReq implementHoverExecuteProgressReq_1 = new ImplementHoverExecuteProgressReq();
                        implementHoverExecuteProgressReq_1.setExecuteProgressValue(Double.valueOf(0));//CUSTOM_CONVENTION//sourceId:985821_1_43166
                        if (finalOmsExecuteProgress != null) {
                            implementHoverExecuteProgressReq_1.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:987830_1_43166
                        }
                        if (reqDto != null) {
                            implementHoverExecuteProgressReq_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990436_1_43166
                        }

                        /*3-15-01执行悬停执行进度（悬停0）[6964]   */
                        Assert.isNull(implementHoverExecuteProgressReq_1.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停0）-执行进度记录ID不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_1.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停0）-执行进度值不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_1.getThemeContentId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停0）-主题内容ID不能为空", false);
                        omsExecuteProgress_5 = mOmsExecuteProgressService.implementHoverExecuteProgress(implementHoverExecuteProgressReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_1;
                    if (omsExecuteProgress_5 != null) {
                        OmsExecuteProgress omsExecuteProgress_7 = new OmsExecuteProgress();
                        if (omsExecuteProgress_5 != null) {
                            omsExecuteProgress_7.setExecuteProgressId(omsExecuteProgress_5.getExecuteProgressId());//SimpleFieldAssign//sourceId:985813_1_43167
                        }
                        if (reqDto != null) {
                            omsExecuteProgress_7.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:985814_1_43167
                        }

                        /*3-15-01修改执行进度[6960]   */
                        Assert.isNull(omsExecuteProgress_7.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01修改执行进度-执行进度记录ID不能为空", false);
                        Assert.isNull(omsExecuteProgress_7.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01修改执行进度-执行进度值不能为空", false);
                        bOOLEAN_1 = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_7)/*vcase invoke 本地 method 方法调用;*/;


                    }
                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("2") && finalOmsExecuteProgress != null && finalOmsExecuteProgress.getIsComplete() != null && finalOmsExecuteProgress.getIsComplete().equals("FALSE"))) {
                    //elseif((D3更新执行周期执行进度处理进度(公共).处理步骤 等于 2 and 3-15-01查执行进度详情.是否已完成 等于 否))  43168

                    OmsExecuteProgress omsExecuteProgress_8 = null;
                    if (finalOmsExecuteProgress != null) {
                        ImplementHoverExecuteProgressReq implementHoverExecuteProgressReq_2 = new ImplementHoverExecuteProgressReq();
                        implementHoverExecuteProgressReq_2.setExecuteProgressValue(Double.valueOf(20));//CUSTOM_CONVENTION//sourceId:985829_1_43171
                        if (finalOmsExecuteProgress != null) {
                            implementHoverExecuteProgressReq_2.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:987832_1_43171
                        }
                        if (reqDto != null) {
                            implementHoverExecuteProgressReq_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990437_1_43171
                        }

                        /*3-15-01执行悬停执行进度（悬停20）[6964]   */
                        Assert.isNull(implementHoverExecuteProgressReq_2.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停20）-执行进度记录ID不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_2.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停20）-执行进度值不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_2.getThemeContentId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停20）-主题内容ID不能为空", false);
                        omsExecuteProgress_8 = mOmsExecuteProgressService.implementHoverExecuteProgress(implementHoverExecuteProgressReq_2)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_2;
                    if (omsExecuteProgress_8 != null) {
                        OmsExecuteProgress omsExecuteProgress_10 = new OmsExecuteProgress();
                        if (omsExecuteProgress_8 != null) {
                            omsExecuteProgress_10.setExecuteProgressId(omsExecuteProgress_8.getExecuteProgressId());//SimpleFieldAssign//sourceId:985813_1_43172
                        }
                        if (reqDto != null) {
                            omsExecuteProgress_10.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:985814_1_43172
                        }

                        /*3-15-01修改执行进度[6960]   */
                        Assert.isNull(omsExecuteProgress_10.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01修改执行进度-执行进度记录ID不能为空", false);
                        Assert.isNull(omsExecuteProgress_10.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01修改执行进度-执行进度值不能为空", false);
                        bOOLEAN_2 = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_10)/*vcase invoke 本地 method 方法调用;*/;


                    }
                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("3") && finalOmsExecuteProgress != null && finalOmsExecuteProgress.getIsComplete() != null && finalOmsExecuteProgress.getIsComplete().equals("FALSE"))) {
                    //elseif((D3更新执行周期执行进度处理进度(公共).处理步骤 等于 3 and 3-15-01查执行进度详情.是否已完成 等于 否))  43173

                    OmsExecuteProgress omsExecuteProgress_11 = null;
                    if (finalOmsExecuteProgress != null) {
                        ImplementHoverExecuteProgressReq implementHoverExecuteProgressReq_3 = new ImplementHoverExecuteProgressReq();
                        implementHoverExecuteProgressReq_3.setExecuteProgressValue(Double.valueOf(50));//CUSTOM_CONVENTION//sourceId:985837_1_43175
                        if (finalOmsExecuteProgress != null) {
                            implementHoverExecuteProgressReq_3.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:987833_1_43175
                        }
                        if (reqDto != null) {
                            implementHoverExecuteProgressReq_3.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990438_1_43175
                        }

                        /*3-15-01执行悬停执行进度（悬停50）[6964]   */
                        Assert.isNull(implementHoverExecuteProgressReq_3.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停50）-执行进度记录ID不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_3.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停50）-执行进度值不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_3.getThemeContentId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停50）-主题内容ID不能为空", false);
                        omsExecuteProgress_11 = mOmsExecuteProgressService.implementHoverExecuteProgress(implementHoverExecuteProgressReq_3)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_3;
                    if (omsExecuteProgress_11 != null) {
                        OmsExecuteProgress omsExecuteProgress_13 = new OmsExecuteProgress();
                        if (omsExecuteProgress_11 != null) {
                            omsExecuteProgress_13.setExecuteProgressId(omsExecuteProgress_11.getExecuteProgressId());//SimpleFieldAssign//sourceId:985813_1_43176
                        }
                        if (reqDto != null) {
                            omsExecuteProgress_13.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:985814_1_43176
                        }

                        /*3-15-01修改执行进度[6960]   */
                        Assert.isNull(omsExecuteProgress_13.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01修改执行进度-执行进度记录ID不能为空", false);
                        Assert.isNull(omsExecuteProgress_13.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01修改执行进度-执行进度值不能为空", false);
                        bOOLEAN_3 = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_13)/*vcase invoke 本地 method 方法调用;*/;


                    }
                } else if ((reqDto != null && reqDto.getBatchHandleStep() != null && reqDto.getBatchHandleStep().equals("100") && finalOmsExecuteProgress != null && finalOmsExecuteProgress.getIsComplete() != null && finalOmsExecuteProgress.getIsComplete().equals("FALSE"))) {
                    //elseif((D3更新执行周期执行进度处理进度(公共).处理步骤 等于 100 and 3-15-01查执行进度详情.是否已完成 等于 否))  43180

                    OmsExecuteProgress omsExecuteProgress_14 = null;
                    if (finalOmsExecuteProgress != null) {
                        ImplementHoverExecuteProgressReq implementHoverExecuteProgressReq_4 = new ImplementHoverExecuteProgressReq();
                        implementHoverExecuteProgressReq_4.setExecuteProgressValue(Double.valueOf(95));//CUSTOM_CONVENTION//sourceId:985877_1_43181
                        if (finalOmsExecuteProgress != null) {
                            implementHoverExecuteProgressReq_4.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:987836_1_43181
                        }
                        if (reqDto != null) {
                            implementHoverExecuteProgressReq_4.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990439_1_43181
                        }

                        /*3-15-01执行悬停执行进度（悬停95）[6964]   */
                        Assert.isNull(implementHoverExecuteProgressReq_4.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停95）-执行进度记录ID不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_4.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停95）-执行进度值不能为空", false);
                        Assert.isNull(implementHoverExecuteProgressReq_4.getThemeContentId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01执行悬停执行进度（悬停95）-主题内容ID不能为空", false);
                        omsExecuteProgress_14 = mOmsExecuteProgressService.implementHoverExecuteProgress(implementHoverExecuteProgressReq_4)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    boolean bOOLEAN_4;
                    if (omsExecuteProgress_14 != null) {
                        OmsExecuteProgress omsExecuteProgress_16 = new OmsExecuteProgress();
                        omsExecuteProgress_16.setIsComplete("TRUE");//sourceId:985819_1_43182
                        if (omsExecuteProgress_14 != null) {
                            omsExecuteProgress_16.setExecuteProgressId(omsExecuteProgress_14.getExecuteProgressId());//SimpleFieldAssign//sourceId:985817_1_43182
                        }
                        if (reqDto != null) {
                            omsExecuteProgress_16.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:985818_1_43182
                        }

                        /*3-15-01更新执行进度处理完成[6960]   */
                        Assert.isNull(omsExecuteProgress_16.getExecuteProgressId(), "D3更新执行周期执行进度处理进度(公共)-3-15-01更新执行进度处理完成-执行进度记录ID不能为空", false);
                        Assert.isNull(omsExecuteProgress_16.getExecuteProgressValue(), "D3更新执行周期执行进度处理进度(公共)-3-15-01更新执行进度处理完成-执行进度值不能为空", false);
                        Assert.isNull(omsExecuteProgress_16.getIsComplete(), "D3更新执行周期执行进度处理进度(公共)-3-15-01更新执行进度处理完成-是否已完成不能为空", false);
                        bOOLEAN_4 = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_16)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
//virtualUsage M3异步结束  43159
                //ModelCode: asynchronizationEnd
                return "";
            }
        };
        CommonFunctionHelper.asynExcute(call);
        RefreshExecuteProgressDisposeComRespDto retData = new RefreshExecuteProgressDisposeComRespDto();


        return retData;
    }

    /**
     * D3查步骤执行进度情况[6966]
     * gen by moon at 7/6/2023, 10:37:58 PM
     */
    @Trace(operationName = "D3查步骤执行进度情况")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStepExecuteProgressDetailRespDto queryStepExecuteProgressDetail(QueryStepExecuteProgressDetailReqDto reqDto) {


        ImplementQueryCacheProgressRespDto queryCacheProgressRes_1 = null;
        ObtainProgressLoadingBgComRespDto obtainProgressLoadingBgComRespDto_1 = null;
//virtualUsage M3执行查缓存进度值(特殊方法）  47313
        //ModelCode: queryCacheProgress
        ImplementQueryCacheProgressRespDto queryCacheProgressRes = null;
        ImplementQueryCacheProgressReqDto queryCacheProgressReq = new ImplementQueryCacheProgressReqDto();
        if (reqDto != null) {
            queryCacheProgressReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1080353_1_47313
            queryCacheProgressReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1080354_1_47313
            queryCacheProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1080355_1_47313
        }

        /*M3执行查缓存进度值(特殊方法）[7290]  用于查缓存进度值 */
        Assert.isNull(queryCacheProgressReq.getObjectId(), "D3查步骤执行进度情况-M3执行查缓存进度值(特殊方法）-归属对象内容ID不能为空", false);
        Assert.isNull(queryCacheProgressReq.getUseTypeCode(), "D3查步骤执行进度情况-M3执行查缓存进度值(特殊方法）-用途类型编码不能为空", false);
        Assert.isNull(queryCacheProgressReq.getThemeContentId(), "D3查步骤执行进度情况-M3执行查缓存进度值(特殊方法）-主题内容ID不能为空", false);
        queryCacheProgressRes = nbExecuteProgress.implementQueryCacheProgress(queryCacheProgressReq);


        queryCacheProgressRes_1 = queryCacheProgressRes;
        if ((reqDto != null && reqDto.getCustomField() != null && reqDto.getCustomField().equals("0"))) {
            //if(D3查步骤执行进度情况.是否精准进度查询背景图 等于 0)  43185

            ObtainProgressLoadingBgComRespDto obtainProgressLoadingBgComRespDto = null;
            ObtainProgressLoadingBgComReqDto obtainProgressLoadingBgComReqDto = new ObtainProgressLoadingBgComReqDto();
            if (queryCacheProgressRes != null) {
                obtainProgressLoadingBgComReqDto.setExtensionField1(queryCacheProgressRes.getExecuteProgressValue() != null ? String.valueOf(queryCacheProgressRes.getExecuteProgressValue()) : "");//SimpleFieldAssign//sourceId:985936_1_43186
            }
            if (reqDto != null) {
                obtainProgressLoadingBgComReqDto.setConfItemCode(reqDto.getConfItemCode());//SimpleFieldAssign//sourceId:985931_1_43186
            }

            /*D2获取进度加载背景图(公共)[6957]   */
            Assert.isNull(obtainProgressLoadingBgComReqDto.getExtensionField1(), "D3查步骤执行进度情况-D2获取进度加载背景图(公共)-当前进度值不能为空", false);
            Assert.isNull(obtainProgressLoadingBgComReqDto.getConfItemCode(), "D3查步骤执行进度情况-D2获取进度加载背景图(公共)-配置项标识不能为空", false);
            obtainProgressLoadingBgComRespDto = confSchemeService.obtainProgressLoadingBgCom(obtainProgressLoadingBgComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            obtainProgressLoadingBgComRespDto_1 = obtainProgressLoadingBgComRespDto;
        } else if ((reqDto != null && reqDto.getCustomField() != null && reqDto.getCustomField().equals("1"))) {
            //elseif(D3查步骤执行进度情况.是否精准进度查询背景图 等于 1)  43187

            ImplementAnalyseProgressMatchScopeComRespDto implementAnalyseProgressMatchScopeComRespDto = null;
            ImplementAnalyseProgressMatchScopeComReqDto implementAnalyseProgressMatchScopeComReqDto = new ImplementAnalyseProgressMatchScopeComReqDto();
            if (queryCacheProgressRes != null) {
                implementAnalyseProgressMatchScopeComReqDto.setExecuteProgressValue(queryCacheProgressRes.getExecuteProgressValue());//SimpleFieldAssign//sourceId:986106_1_43190
            }

            /*D3执行分析进度值匹配进度范围(公共)[6967]   */
            Assert.isNull(implementAnalyseProgressMatchScopeComReqDto.getExecuteProgressValue(), "D3查步骤执行进度情况-D3执行分析进度值匹配进度范围(公共)-执行进度值不能为空", false);
            implementAnalyseProgressMatchScopeComRespDto = implementAnalyseProgressMatchScopeCom(implementAnalyseProgressMatchScopeComReqDto)/*vcase invoke 同服务,同domain*/;


            ObtainProgressLoadingBgComRespDto obtainProgressLoadingBgComRespDto_2 = null;
            if (implementAnalyseProgressMatchScopeComRespDto != null) {
                ObtainProgressLoadingBgComReqDto obtainProgressLoadingBgComReqDto_1 = new ObtainProgressLoadingBgComReqDto();
                if (implementAnalyseProgressMatchScopeComRespDto != null) {
                    obtainProgressLoadingBgComReqDto_1.setExtensionField1(implementAnalyseProgressMatchScopeComRespDto.getCustomField());//SimpleFieldAssign//sourceId:985936_1_43188
                }
                if (reqDto != null) {
                    obtainProgressLoadingBgComReqDto_1.setConfItemCode(reqDto.getConfItemCode());//SimpleFieldAssign//sourceId:985931_1_43188
                }

                /*D2获取进度加载背景图(公共)[6957]   */
                Assert.isNull(obtainProgressLoadingBgComReqDto_1.getExtensionField1(), "D3查步骤执行进度情况-D2获取进度加载背景图(公共)-当前进度值不能为空", false);
                Assert.isNull(obtainProgressLoadingBgComReqDto_1.getConfItemCode(), "D3查步骤执行进度情况-D2获取进度加载背景图(公共)-配置项标识不能为空", false);
                obtainProgressLoadingBgComRespDto_2 = confSchemeService.obtainProgressLoadingBgCom(obtainProgressLoadingBgComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                obtainProgressLoadingBgComRespDto_1 = obtainProgressLoadingBgComRespDto_2;
            }
        }
        QueryStepExecuteProgressDetailRespDto retData = new QueryStepExecuteProgressDetailRespDto();
        if (queryCacheProgressRes_1 != null) {
            retData.setExecuteProgressValue(queryCacheProgressRes_1.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1080357_1
        }
        if (obtainProgressLoadingBgComRespDto_1 != null) {
            retData.setBackGroundAddress(obtainProgressLoadingBgComRespDto_1.getBackGroundAddress());//SimpleFieldAssign//sourceId:987854_1
            retData.setExtensionField3(obtainProgressLoadingBgComRespDto_1.getExtensionField3());//SimpleFieldAssign//sourceId:1066414_1
        }


        return retData;
    }

    /**
     * D3执行异步增执行进度(公共)[6986]
     * gen by moon at 5/29/2023, 2:23:28 PM
     */
    @Trace(operationName = "D3执行异步增执行进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAsyncAddExecuteProgressComRespDto implementAsyncAddExecuteProgressCom(ImplementAsyncAddExecuteProgressComReqDto reqDto) {

// TODO: 2023/5/28 手写代码，这块月光宝盒要特殊对接
        final String[] string_1 = {null};
//virtualUsage 3-15-01查执行进度是否存在  43380
        OmsExecuteProgress omsExecuteProgress = null;
        QueryExecuteProgressDetailReq queryExecuteProgressDetailReq = new QueryExecuteProgressDetailReq();
        if (reqDto != null) {
            queryExecuteProgressDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:988960_1_43380
            queryExecuteProgressDetailReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:988961_1_43380
            queryExecuteProgressDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:988962_1_43380
        }

        /*3-15-01查执行进度是否存在[6959]   */
        Assert.isNull(queryExecuteProgressDetailReq.getObjectId(), "D3执行异步增执行进度(公共)-3-15-01查执行进度是否存在-归属对象内容ID不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getUseTypeCode(), "D3执行异步增执行进度(公共)-3-15-01查执行进度是否存在-用途类型编码不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getThemeContentId(), "D3执行异步增执行进度(公共)-3-15-01查执行进度是否存在-主题内容ID不能为空", false);
        omsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage M3异步开始  43321
        //ModelCode: asynchronizationStart
        OmsExecuteProgress finalOmsExecuteProgress = omsExecuteProgress;
        Callable<String> call = new Callable<String>() {

            @Override
            public String call() throws Exception {
                //执行方法
//virtualUsage M3业务应用公共字段推送内存  43323
                //ModelCode: publicFieldCache
                ImplementBizPublicFieldPushMemoryRespDto publicFieldCacheRes = null;
                if (finalOmsExecuteProgress != null) {
                    ImplementBizPublicFieldPushMemoryReqDto publicFieldCacheReq = new ImplementBizPublicFieldPushMemoryReqDto();
                    if (finalOmsExecuteProgress != null) {
                        publicFieldCacheReq.setCreateInductionId(finalOmsExecuteProgress.getCreateInductionId());//SimpleFieldAssign//sourceId:988896_1_43323
                        publicFieldCacheReq.setSpaceId(finalOmsExecuteProgress.getSpaceId());//SimpleFieldAssign//sourceId:988897_1_43323
                        publicFieldCacheReq.setAppId(finalOmsExecuteProgress.getAppId());//SimpleFieldAssign//sourceId:988898_1_43323
                    }

                    /*M3业务应用公共字段推送内存[4520]  用于定时任务执行时，获取定时任务执行所需的公共信息，存入缓存，供定时任务中虚拟用况使用 */
                    Assert.isNull(publicFieldCacheReq.getCreateInductionId(), "D3执行异步增执行进度(公共)-M3业务应用公共字段推送内存-创建人就职记录ID 不能为空", false);
                    Assert.isNull(publicFieldCacheReq.getSpaceId(), "D3执行异步增执行进度(公共)-M3业务应用公共字段推送内存-创建于空间ID不能为空", false);
                    Assert.isNull(publicFieldCacheReq.getAppId(), "D3执行异步增执行进度(公共)-M3业务应用公共字段推送内存-创建于联盟应用ID不能为空", false);
                    publicFieldCacheRes = nbExecuteProgress.implementBizPublicFieldPushMemory(publicFieldCacheReq);


                }
                if ((finalOmsExecuteProgress == null)) {
                    //if(3-15-01查执行进度是否存在.出参 值等于空 )  43331

                    String string = null;
                    OmsExecuteProgress omsExecuteProgress_2 = new OmsExecuteProgress();
                    omsExecuteProgress_2.setIsComplete("FALSE");//sourceId:988900_1_43332
                    if (reqDto != null) {
                        omsExecuteProgress_2.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:988902_1_43332
                        omsExecuteProgress_2.setAsyncExecuteState(reqDto.getAsyncExecuteState());//SimpleFieldAssign//sourceId:988908_1_43332
                        omsExecuteProgress_2.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:988901_1_43332
                        omsExecuteProgress_2.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:988903_1_43332
                        omsExecuteProgress_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:988904_1_43332
                        omsExecuteProgress_2.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:988905_1_43332
                        omsExecuteProgress_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:988906_1_43332
                    }

                    /*3-15-01新增执行进度[6958]   */
                    Assert.isNull(omsExecuteProgress_2.getExecuteProgressValue(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-执行进度值不能为空", false);
                    Assert.isNull(omsExecuteProgress_2.getIsComplete(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-是否已完成不能为空", false);
                    Assert.isNull(omsExecuteProgress_2.getUseTypeCode(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-用途类型编码不能为空", false);
                    Assert.isNull(omsExecuteProgress_2.getObjectTypeCode(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-归属对象类型编码不能为空", false);
                    Assert.isNull(omsExecuteProgress_2.getObjectId(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-归属对象内容ID不能为空", false);
                    Assert.isNull(omsExecuteProgress_2.getThemeContentTypeCode(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-主题内容类型编码不能为空", false);
                    Assert.isNull(omsExecuteProgress_2.getThemeContentId(), "D3执行异步增执行进度(公共)-3-15-01新增执行进度-主题内容ID不能为空", false);
                    string = mOmsExecuteProgressService.addExecuteProgress(omsExecuteProgress_2)/*vcase invoke 本地 method 方法调用;*/;

// TODO: 2023/5/28 手写代码，这块月光宝盒要特殊对接  
                    string_1[0] = string;
                } else if ((finalOmsExecuteProgress != null)) {
                    //elseif(3-15-01查执行进度是否存在.出参 值不等于空 )  43333

                    boolean bOOLEAN;
                    if (finalOmsExecuteProgress != null) {
                        OmsExecuteProgress omsExecuteProgress_3 = new OmsExecuteProgress();
                        omsExecuteProgress_3.setIsComplete("FALSE");//sourceId:988978_1_43334
                        if (finalOmsExecuteProgress != null) {
                            omsExecuteProgress_3.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:988976_1_43334
                        }
                        if (reqDto != null) {
                            omsExecuteProgress_3.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:988977_1_43334
                            omsExecuteProgress_3.setAsyncExecuteState(reqDto.getAsyncExecuteState());//SimpleFieldAssign//sourceId:988979_1_43334
                        }

                        /*3-15-01修改执行进度[6960]   */
                        Assert.isNull(omsExecuteProgress_3.getExecuteProgressId(), "D3执行异步增执行进度(公共)-3-15-01修改执行进度-执行进度记录ID不能为空", false);
                        Assert.isNull(omsExecuteProgress_3.getExecuteProgressValue(), "D3执行异步增执行进度(公共)-3-15-01修改执行进度-执行进度值不能为空", false);
                        Assert.isNull(omsExecuteProgress_3.getIsComplete(), "D3执行异步增执行进度(公共)-3-15-01修改执行进度-是否已完成不能为空", false);
                        bOOLEAN = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_3)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
//virtualUsage M3异步结束  43322
                //ModelCode: asynchronizationEnd
                return "";
            }
        };
        CommonFunctionHelper.asynExcute(call);
        ImplementAsyncAddExecuteProgressComRespDto retData = new ImplementAsyncAddExecuteProgressComRespDto();
// TODO: 2023/5/28 手写代码，这块月光宝盒要特殊对接    
        if (string_1[0] != null) {
            retData.setExecuteProgressId(string_1[0]);//SimpleFieldAssign//sourceId:988950_1
        }


        return retData;
    }

    /**
     * D3删除执行进度(公共)[6980]
     * gen by moon at 5/28/2023, 9:51:33 PM
     */
    @Trace(operationName = "D3删除执行进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteExecuteProgressComRespDto deleteExecuteProgressCom(DeleteExecuteProgressComReqDto reqDto) {


        //步骤0: 3-15-01查执行进度详情 - queryExecuteProgressDetail
        OmsExecuteProgress omsExecuteProgress = null;
        QueryExecuteProgressDetailReq queryExecuteProgressDetailReq = new QueryExecuteProgressDetailReq();
        if (reqDto != null) {
            queryExecuteProgressDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:988154_1
        }

        /*3-15-01查执行进度详情[6959]   */
        Assert.isNull(queryExecuteProgressDetailReq.getObjectId(), "D3删除执行进度(公共)-3-15-01查执行进度详情-归属对象内容ID不能为空", false);
        omsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-15-01删除执行进度 - deleteExecuteProgress
        boolean bOOLEAN;
        if (omsExecuteProgress != null) {
            String string = new String();
            if (omsExecuteProgress != null) {
                string = omsExecuteProgress.getExecuteProgressId();
                ;//SimpleFieldAssign//sourceId:988161_1
            }

            /*3-15-01删除执行进度[6961]   */
            Assert.isNull(string, "D3删除执行进度(公共)-3-15-01删除执行进度-执行进度记录ID不能为空", false);
            bOOLEAN = mOmsExecuteProgressService.deleteExecuteProgress(string)/*vcase invoke 本地 method 方法调用;*/;


        }

        DeleteExecuteProgressComRespDto retData = new DeleteExecuteProgressComRespDto();


        return retData;
    }

    /**
     * D3执行更新执行进度值(公共)[7006]
     * gen by moon at 6/27/2023, 11:37:29 PM
     */
    @Trace(operationName = "D3执行更新执行进度值(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementUpdateExecuteProgressValueComRespDto implementUpdateExecuteProgressValueCom(ImplementUpdateExecuteProgressValueComReqDto reqDto) {


        OmsExecuteProgress omsExecuteProgress_1 = null;
        //virtualUsage 3-15-01查执行进度详情  43384
        OmsExecuteProgress omsExecuteProgress = null;
        QueryExecuteProgressDetailReq queryExecuteProgressDetailReq = new QueryExecuteProgressDetailReq();
        if (reqDto != null) {
            queryExecuteProgressDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:990394_1_43384
            queryExecuteProgressDetailReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:990395_1_43384
            queryExecuteProgressDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990396_1_43384
        }

        /*3-15-01查执行进度详情[6959]   */
        Assert.isNull(queryExecuteProgressDetailReq.getObjectId(), "D3执行更新执行进度值(公共)-3-15-01查执行进度详情-归属对象内容ID不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getUseTypeCode(), "D3执行更新执行进度值(公共)-3-15-01查执行进度详情-用途类型编码不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getThemeContentId(), "D3执行更新执行进度值(公共)-3-15-01查执行进度详情-主题内容ID不能为空", false);
        omsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        omsExecuteProgress_1 = omsExecuteProgress;
        if ((reqDto != null && reqDto.getExecuteProgressValue() != null)) {
            //if(D3执行更新执行进度值(公共).执行进度值 值不等于空 )  43386

//ModelCode: asynchronizationStart
            OmsExecuteProgress finalOmsExecuteProgress = omsExecuteProgress;
            Callable<String> call = new Callable<String>() {

                @Override
                public String call() throws Exception {
                    //执行方法
                    if ((reqDto != null && reqDto.getExecuteProgressValue() != null && reqDto != null && reqDto.getExecuteProgressValue() == 0L)) {
                        //if((D3执行更新执行进度值(公共).执行进度值 值不等于空  and D3执行更新执行进度值(公共).执行进度值 等于 0))  43410

                        if ((finalOmsExecuteProgress != null)) {
                            //if(3-15-01查执行进度详情.出参 值不等于空 )  43416

                            boolean bOOLEAN;
                            if (finalOmsExecuteProgress != null) {
                                OmsExecuteProgress omsExecuteProgress_2 = new OmsExecuteProgress();
                                omsExecuteProgress_2.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:990517_1_43422
                                omsExecuteProgress_2.setIsComplete("FALSE");//sourceId:990518_1_43422
                                omsExecuteProgress_2.setAsyncExecuteState("IN_PROGRESS");//sourceId:1017027_1_43422
                                if (finalOmsExecuteProgress != null) {
                                    omsExecuteProgress_2.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:990516_1_43422
                                }
                                if (reqDto != null) {
                                    omsExecuteProgress_2.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:990520_1_43422
                                }

                                /*3-15-01初始化执行进度为0[7007]   */
                                Assert.isNull(omsExecuteProgress_2.getExecuteProgressId(), "D3执行更新执行进度值(公共)-3-15-01初始化执行进度为0-执行进度记录ID不能为空", false);
                                Assert.isNull(omsExecuteProgress_2.getExecuteProgressValue(), "D3执行更新执行进度值(公共)-3-15-01初始化执行进度为0-执行进度值不能为空", false);
                                Assert.isNull(omsExecuteProgress_2.getIsComplete(), "D3执行更新执行进度值(公共)-3-15-01初始化执行进度为0-是否已完成不能为空", false);
                                Assert.isNull(omsExecuteProgress_2.getAsyncExecuteState(), "D3执行更新执行进度值(公共)-3-15-01初始化执行进度为0-异步执行状态不能为空", false);
                                Assert.isNull(omsExecuteProgress_2.getOperationInductionId(), "D3执行更新执行进度值(公共)-3-15-01初始化执行进度为0-操作人就职记录ID不能为空", false);
                                bOOLEAN = mOmsExecuteProgressService.updateExecuteProgressUnrestraint(omsExecuteProgress_2)/*vcase invoke 本地 method 方法调用;*/;


                            }
                        } else if ((finalOmsExecuteProgress == null)) {
                            //elseif(3-15-01查执行进度详情.出参 值等于空 )  43417

                            String string = null;
                            OmsExecuteProgress omsExecuteProgress_3 = new OmsExecuteProgress();
                            omsExecuteProgress_3.setIsComplete("FALSE");//sourceId:990521_1_43421
                            omsExecuteProgress_3.setAsyncExecuteState("IN_PROGRESS");//sourceId:1017028_1_43421
                            if (reqDto != null) {
                                omsExecuteProgress_3.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:990523_1_43421
                                omsExecuteProgress_3.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:990522_1_43421
                                omsExecuteProgress_3.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:990524_1_43421
                                omsExecuteProgress_3.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:990525_1_43421
                                omsExecuteProgress_3.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:990526_1_43421
                                omsExecuteProgress_3.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990527_1_43421
                                omsExecuteProgress_3.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:990551_1_43421
                                omsExecuteProgress_3.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:990552_1_43421
                                omsExecuteProgress_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:990553_1_43421
                                omsExecuteProgress_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:990554_1_43421
                            }

                            /*3-15-01新增执行进度[6958]   */
                            Assert.isNull(omsExecuteProgress_3.getExecuteProgressValue(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-执行进度值不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getIsComplete(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-是否已完成不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getAsyncExecuteState(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-异步执行状态不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getUseTypeCode(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-用途类型编码不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getObjectTypeCode(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-归属对象类型编码不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getObjectId(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-归属对象内容ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getThemeContentTypeCode(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-主题内容类型编码不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getThemeContentId(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-主题内容ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getOperationInductionId(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-操作人就职记录ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getCreateInductionId(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-创建人就职记录ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getSpaceId(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-创建于空间ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_3.getAppId(), "D3执行更新执行进度值(公共)-3-15-01新增执行进度-创建于联盟应用ID不能为空", false);
                            string = mOmsExecuteProgressService.addExecuteProgress(omsExecuteProgress_3)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    } else if ((reqDto != null && reqDto.getExecuteProgressValue() > 0L)) {
                        //elseif(D3执行更新执行进度值(公共).执行进度值 大于 0)  43411

                        OmsExecuteProgress omsExecuteProgress_4 = null;
                        if (finalOmsExecuteProgress != null) {
                            ImplementHoverExecuteProgressReq implementHoverExecuteProgressReq = new ImplementHoverExecuteProgressReq();
                            if (finalOmsExecuteProgress != null) {
                                implementHoverExecuteProgressReq.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:990422_1_43418
                            }
                            if (reqDto != null) {
                                implementHoverExecuteProgressReq.setExecuteProgressValue(reqDto.getComNumField() != null ? Double.valueOf(reqDto.getComNumField()) : null);//SimpleFieldAssign//sourceId:990423_1_43418
                                implementHoverExecuteProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:990417_1_43418
                            }

                            /*3-15-01执行悬停执行进度[6964]   */
                            Assert.isNull(implementHoverExecuteProgressReq.getExecuteProgressId(), "D3执行更新执行进度值(公共)-3-15-01执行悬停执行进度-执行进度记录ID不能为空", false);
                            Assert.isNull(implementHoverExecuteProgressReq.getExecuteProgressValue(), "D3执行更新执行进度值(公共)-3-15-01执行悬停执行进度-执行进度值不能为空", false);
                            Assert.isNull(implementHoverExecuteProgressReq.getThemeContentId(), "D3执行更新执行进度值(公共)-3-15-01执行悬停执行进度-主题内容ID不能为空", false);
                            omsExecuteProgress_4 = mOmsExecuteProgressService.implementHoverExecuteProgress(implementHoverExecuteProgressReq)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        boolean bOOLEAN_1;
                        if (omsExecuteProgress_4 != null) {
                            OmsExecuteProgress omsExecuteProgress_6 = new OmsExecuteProgress();
                            if (omsExecuteProgress_4 != null) {
                                omsExecuteProgress_6.setExecuteProgressId(omsExecuteProgress_4.getExecuteProgressId());//SimpleFieldAssign//sourceId:990430_1_43419
                            }
                            if (reqDto != null) {
                                omsExecuteProgress_6.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:990431_1_43419
                                omsExecuteProgress_6.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:990434_1_43419
                            }

                            /*3-15-01更新执行进度值[7007]   */
                            Assert.isNull(omsExecuteProgress_6.getExecuteProgressId(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度值-执行进度记录ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_6.getExecuteProgressValue(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度值-执行进度值不能为空", false);
                            Assert.isNull(omsExecuteProgress_6.getOperationInductionId(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度值-操作人就职记录ID不能为空", false);
                            bOOLEAN_1 = mOmsExecuteProgressService.updateExecuteProgressUnrestraint(omsExecuteProgress_6)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    }
                    if ((reqDto != null && reqDto.getExecuteProgressValue() == 100L)) {
                        //if(D3执行更新执行进度值(公共).执行进度值 等于 100)  43407

                        boolean bOOLEAN_2;
                        if (finalOmsExecuteProgress != null) {
                            OmsExecuteProgress omsExecuteProgress_7 = new OmsExecuteProgress();
                            omsExecuteProgress_7.setIsComplete("TRUE");//sourceId:990452_1_43408
                            omsExecuteProgress_7.setAsyncExecuteState("COMPLETED");//sourceId:1017029_1_43408
                            if (finalOmsExecuteProgress != null) {
                                omsExecuteProgress_7.setExecuteProgressId(finalOmsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:990450_1_43408
                            }
                            if (reqDto != null) {
                                omsExecuteProgress_7.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:990454_1_43408
                            }

                            /*3-15-01更新执行进度为已完成[7007]   */
                            Assert.isNull(omsExecuteProgress_7.getExecuteProgressId(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度为已完成-执行进度记录ID不能为空", false);
                            Assert.isNull(omsExecuteProgress_7.getIsComplete(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度为已完成-是否已完成不能为空", false);
                            Assert.isNull(omsExecuteProgress_7.getAsyncExecuteState(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度为已完成-异步执行状态不能为空", false);
                            Assert.isNull(omsExecuteProgress_7.getOperationInductionId(), "D3执行更新执行进度值(公共)-3-15-01更新执行进度为已完成-操作人就职记录ID不能为空", false);
                            bOOLEAN_2 = mOmsExecuteProgressService.updateExecuteProgressUnrestraint(omsExecuteProgress_7)/*vcase invoke 本地 method 方法调用;*/;


                        }
                    }
//ModelCode: asynchronizationEnd
                    return "";
                }
            };
            CommonFunctionHelper.asynExcute(call);
        }
        ImplementUpdateExecuteProgressValueComRespDto retData = new ImplementUpdateExecuteProgressValueComRespDto();
        if (omsExecuteProgress_1 != null) {
            retData.setExecuteProgressId(omsExecuteProgress_1.getExecuteProgressId());//SimpleFieldAssign//sourceId:1037475_1
        }


        return retData;
    }

    /**
     * D3分析用途类型匹配配置项标识(公共)[7025]
     * gen by moon at 6/24/2023, 7:54:37 PM
     */
    @Trace(operationName = "D3分析用途类型匹配配置项标识(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalyseUseTypeCodeMatchConfCodeComRespDto implementAnalyseUseTypeCodeMatchConfCodeCom(ImplementAnalyseUseTypeCodeMatchConfCodeComReqDto reqDto) {


        ImplementGainInParameterFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage D2-3查当前进度用途类型是否个性背景图  45926
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("PROGRESS_USE_TYPE");//CUSTOM_CONVENTION//sourceId:1053053_1_45926
        queryConfItemMatchAnswerDetailComReqDto.setExtensionField1("TRUE");//CUSTOM_CONVENTION//sourceId:1053059_1_45926
        queryConfItemMatchAnswerDetailComReqDto.setConfSchemeCode("COM_CONF_SCHEME");//CUSTOM_CONVENTION//sourceId:1053054_1_45926
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:1053055_1_45926
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setConfOptionCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1058275_1_45926
        }

        /*D2-3查当前进度用途类型是否个性背景图[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfOptionCode(), "D3分析用途类型匹配配置项标识(公共)-D2-3查当前进度用途类型是否个性背景图-选项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3分析用途类型匹配配置项标识(公共)-D2-3查当前进度用途类型是否个性背景图-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getExtensionField1(), "D3分析用途类型匹配配置项标识(公共)-D2-3查当前进度用途类型是否个性背景图-扩展字段1 （非必填）不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeCode(), "D3分析用途类型匹配配置项标识(公共)-D2-3查当前进度用途类型是否个性背景图-配置方案标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3分析用途类型匹配配置项标识(公共)-D2-3查当前进度用途类型是否个性背景图-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null)) {
            //if(D2-3查当前进度用途类型是否个性背景图.答案值 值不等于空 )  43524

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq = new ImplementGainInParameterFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq.setConfItemCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:991894_1_43525
            }

            /*M3接收进度背景图配置项[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getConfItemCode(), "D3分析用途类型匹配配置项标识(公共)-M3接收进度背景图配置项-配置项标识不能为空", false);
            receptionServiceRes = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        } else if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() == null)) {
            //elseif(D2-3查当前进度用途类型是否个性背景图.答案值 值等于空 )  45927

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_2 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_1 = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq_1.setConfItemCode("GENERAL_PROGRESS_BG");//CUSTOM_CONVENTION//sourceId:991895_1_45928

            /*M3约定为：通用进度背景图配置项标识[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getConfItemCode(), "D3分析用途类型匹配配置项标识(公共)-M3约定为：通用进度背景图配置项标识-配置项标识不能为空", false);
            receptionServiceRes_2 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_1);


//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_4 = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq_2 = new ImplementGainInParameterFieldsReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_2.setConfItemCode(receptionServiceRes_2.getConfItemCode());//SimpleFieldAssign//sourceId:991894_1_45929
            }

            /*M3接收进度背景图配置项[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getConfItemCode(), "D3分析用途类型匹配配置项标识(公共)-M3接收进度背景图配置项-配置项标识不能为空", false);
            receptionServiceRes_4 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_2);


            receptionServiceRes_1 = receptionServiceRes_4;
        }
        ImplementAnalyseUseTypeCodeMatchConfCodeComRespDto retData = new ImplementAnalyseUseTypeCodeMatchConfCodeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setConfItemCode(receptionServiceRes_1.getConfItemCode());//SimpleFieldAssign//sourceId:991897_1
        }


        return retData;
    }


    /**
     * D3执行统计更新执行进度(公共)[7094]
     * gen by moon at 5/26/2024, 11:07:50 PM
     */
    @Trace(operationName = "D3执行统计更新执行进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressCom(ImplementStatisticsUpdateExecuteProgressComReqDto reqDto) {


        ImplementUpdateCacheProgressRespDto updateCacheProgressRes_1 = null;
        if ((reqDto != null && reqDto.getExecuteProgressValue() != null && reqDto != null && reqDto.getExecuteProgressValue() == 0)) {
            //if((D3执行统计更新执行进度(公共).执行进度值 值不等于空  and D3执行统计更新执行进度(公共).执行进度值 等于 0))  47323

//ModelCode: updateCacheProgress
            ImplementUpdateCacheProgressRespDto updateCacheProgressRes = null;
            ImplementUpdateCacheProgressReqDto updateCacheProgressReq = new ImplementUpdateCacheProgressReqDto();
            if (reqDto != null) {
                updateCacheProgressReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819338_1_47324
                updateCacheProgressReq.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1080027_1_47324
                updateCacheProgressReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1080028_1_47324
                updateCacheProgressReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1080029_1_47324
                updateCacheProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1080030_1_47324
                updateCacheProgressReq.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1819340_1_47324
                updateCacheProgressReq.setDuration(reqDto.getDuration());//SimpleFieldAssign//sourceId:1081934_1_47324
            }

            /*M3执行更新缓存进度值[7289]  用于缓存进度值的数值加 */
            Assert.isNull(updateCacheProgressReq.getExecuteProgressValue(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-执行进度值不能为空", false);
            Assert.isNull(updateCacheProgressReq.getObjectId(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-归属对象内容ID不能为空", false);
            Assert.isNull(updateCacheProgressReq.getUseTypeCode(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-用途类型编码不能为空", false);
            Assert.isNull(updateCacheProgressReq.getThemeContentId(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-主题内容ID不能为空", false);
            updateCacheProgressRes = nbExecuteProgress.implementUpdateCacheProgress(updateCacheProgressReq);


            updateCacheProgressRes_1 = updateCacheProgressRes;
        } else if ((reqDto != null && reqDto.getExecuteProgressValue() != null && reqDto != null && reqDto.getExecuteProgressValue() > 0)) {
            //elseif((D3执行统计更新执行进度(公共).执行进度值 值不等于空  and D3执行统计更新执行进度(公共).执行进度值 大于 0))  47325

//ModelCode: updateCacheProgress
            ImplementUpdateCacheProgressRespDto updateCacheProgressRes_2 = null;
            ImplementUpdateCacheProgressReqDto updateCacheProgressReq_1 = new ImplementUpdateCacheProgressReqDto();
            if (reqDto != null) {
                updateCacheProgressReq_1.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819338_1_47329
                updateCacheProgressReq_1.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1080027_1_47329
                updateCacheProgressReq_1.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1080028_1_47329
                updateCacheProgressReq_1.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1080029_1_47329
                updateCacheProgressReq_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1080030_1_47329
                updateCacheProgressReq_1.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1819340_1_47329
            }

            /*M3执行更新缓存进度值[7289]  用于缓存进度值的数值加 */
            Assert.isNull(updateCacheProgressReq_1.getExecuteProgressValue(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-执行进度值不能为空", false);
            Assert.isNull(updateCacheProgressReq_1.getObjectId(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-归属对象内容ID不能为空", false);
            Assert.isNull(updateCacheProgressReq_1.getUseTypeCode(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-用途类型编码不能为空", false);
            Assert.isNull(updateCacheProgressReq_1.getThemeContentId(), "D3执行统计更新执行进度(公共)-M3执行更新缓存进度值-主题内容ID不能为空", false);
            updateCacheProgressRes_2 = nbExecuteProgress.implementUpdateCacheProgress(updateCacheProgressReq_1);


            updateCacheProgressRes_1 = updateCacheProgressRes_2;
        } else if ((reqDto != null && reqDto.getIsComplete() != null && reqDto.getIsComplete().equals("TRUE") && reqDto != null && reqDto.getExecuteProgressValue() == null)) {
            //elseif((D3执行统计更新执行进度(公共).是否已完成 等于 是 and D3执行统计更新执行进度(公共).执行进度值 值等于空 ))  47327

//ModelCode: updateCacheProgress
            ImplementUpdateCacheProgressRespDto updateCacheProgressRes_3 = null;
            ImplementUpdateCacheProgressReqDto updateCacheProgressReq_2 = new ImplementUpdateCacheProgressReqDto();
            updateCacheProgressReq_2.setExecuteProgressValue(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1081066_1_47328
            if (reqDto != null) {
                updateCacheProgressReq_2.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819341_1_47328
                updateCacheProgressReq_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1081067_1_47328
                updateCacheProgressReq_2.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081068_1_47328
                updateCacheProgressReq_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1081069_1_47328
                updateCacheProgressReq_2.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1819342_1_47328
            }

            /*M3更新缓存进度值（解锁）[7289]  用于缓存进度值的数值加 */
            Assert.isNull(updateCacheProgressReq_2.getExecuteProgressValue(), "D3执行统计更新执行进度(公共)-M3更新缓存进度值（解锁）-执行进度值不能为空", false);
            Assert.isNull(updateCacheProgressReq_2.getObjectId(), "D3执行统计更新执行进度(公共)-M3更新缓存进度值（解锁）-归属对象内容ID不能为空", false);
            Assert.isNull(updateCacheProgressReq_2.getUseTypeCode(), "D3执行统计更新执行进度(公共)-M3更新缓存进度值（解锁）-用途类型编码不能为空", false);
            Assert.isNull(updateCacheProgressReq_2.getThemeContentId(), "D3执行统计更新执行进度(公共)-M3更新缓存进度值（解锁）-主题内容ID不能为空", false);
            updateCacheProgressRes_3 = nbExecuteProgress.implementUpdateCacheProgress(updateCacheProgressReq_2);


        }
        ImplementStatisticsUpdateExecuteProgressComRespDto retData = new ImplementStatisticsUpdateExecuteProgressComRespDto();
        if (updateCacheProgressRes_1 != null) {
            retData.setLockState(updateCacheProgressRes_1.getLockState());//SimpleFieldAssign//sourceId:1081971_1
            retData.setTureOrFalse(updateCacheProgressRes_1.getTureOrFalse());//SimpleFieldAssign//sourceId:1086357_1
        }


        return retData;
    }

    /**
     * D3判断执行进度运行条件(公共)[7151]
     * gen by moon at 7/7/2023, 2:16:58 PM
     */
    @Trace(operationName = "D3判断执行进度运行条件(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementJudgeExecuteProgressTermComRespDto implementJudgeExecuteProgressTermCom(ImplementJudgeExecuteProgressTermComReqDto reqDto) {


        //virtualUsage M3查缓存进度上锁状态  47332
        //ModelCode: queryCacheProgress
        ImplementQueryCacheProgressRespDto queryCacheProgressRes = null;
        ImplementQueryCacheProgressReqDto queryCacheProgressReq = new ImplementQueryCacheProgressReqDto();
        if (reqDto != null) {
            queryCacheProgressReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1081411_1_47332
            queryCacheProgressReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081412_1_47332
            queryCacheProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1081413_1_47332
        }

        /*M3查缓存进度上锁状态[7290]  用于查缓存进度值 */
        Assert.isNull(queryCacheProgressReq.getObjectId(), "D3判断执行进度运行条件(公共)-M3查缓存进度上锁状态-归属对象内容ID不能为空", false);
        Assert.isNull(queryCacheProgressReq.getUseTypeCode(), "D3判断执行进度运行条件(公共)-M3查缓存进度上锁状态-用途类型编码不能为空", false);
        Assert.isNull(queryCacheProgressReq.getThemeContentId(), "D3判断执行进度运行条件(公共)-M3查缓存进度上锁状态-主题内容ID不能为空", false);
        queryCacheProgressRes = nbExecuteProgress.implementQueryCacheProgress(queryCacheProgressReq);


        if ((queryCacheProgressRes != null && queryCacheProgressRes.getLockState() != null && queryCacheProgressRes.getLockState().equals("LOCKING"))) {
            //if(M3查缓存进度上锁状态.上锁状态 等于 锁定中)  44503

//异常结束 44504
            throw new BizException("C00241", "操作过于频繁，请稍后再试~", false);
        }
        ImplementJudgeExecuteProgressTermComRespDto retData = new ImplementJudgeExecuteProgressTermComRespDto();


        return retData;
    }

    /**
     * D3删除归属对象内容下执行进度(公共)[7159]
     * gen by moon at 6/8/2023, 1:42:49 AM
     */
    @Trace(operationName = "D3删除归属对象内容下执行进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteObjectExecuteProgressComRespDto deleteObjectExecuteProgressCom(DeleteObjectExecuteProgressComReqDto reqDto) {


        //步骤0: 3-15-01查执行进度列表 - queryExecuteProgressList
        List<OmsExecuteProgress> listOmsExecuteProgress = new ArrayList<>();
        QueryExecuteProgressListReq queryExecuteProgressListReq = new QueryExecuteProgressListReq();
        if (reqDto != null) {
            queryExecuteProgressListReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1022327_1
            queryExecuteProgressListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1022328_1
        }

        /*3-15-01查执行进度列表[7160]   */
        Assert.isNull(queryExecuteProgressListReq.getObjectId(), "D3删除归属对象内容下执行进度(公共)-3-15-01查执行进度列表-归属对象内容ID不能为空", false);
        Assert.isNull(queryExecuteProgressListReq.getThemeContentId(), "D3删除归属对象内容下执行进度(公共)-3-15-01查执行进度列表-主题内容ID不能为空", false);
        listOmsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressList(queryExecuteProgressListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-15-01批量删执行进度 - batchDeleteExecuteProgress
        boolean bOOLEAN;
        if (listOmsExecuteProgress != null && !CollectionUtil.isEmpty(listOmsExecuteProgress) && listOmsExecuteProgress.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsExecuteProgress != null && !CollectionUtil.isEmpty(listOmsExecuteProgress) && listOmsExecuteProgress != null && !CollectionUtil.isEmpty(listOmsExecuteProgress)) {
                listString = listOmsExecuteProgress.stream().map(item -> item.getExecuteProgressId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:1022321_1
            }

            /*3-15-01批量删执行进度[6981]   */

            bOOLEAN = mOmsExecuteProgressService.batchDeleteExecuteProgress(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        DeleteObjectExecuteProgressComRespDto retData = new DeleteObjectExecuteProgressComRespDto();


        return retData;
    }

    /**
     * D3重置执行进度(公共)[7207]
     * gen by moon at 6/12/2023, 7:30:21 AM
     */
    @Trace(operationName = "D3重置执行进度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResetExecuteProgressComRespDto resetExecuteProgressCom(ResetExecuteProgressComReqDto reqDto) {


        //步骤0: 3-15-01修改执行进度 - updateExecuteProgress
        boolean bOOLEAN;
        OmsExecuteProgress omsExecuteProgress = new OmsExecuteProgress();
        if (reqDto != null) {
            omsExecuteProgress.setExecuteProgressId(reqDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1037459_1
            omsExecuteProgress.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1037460_1
            omsExecuteProgress.setIsComplete(reqDto.getIsComplete());//SimpleFieldAssign//sourceId:1037461_1
            omsExecuteProgress.setAsyncExecuteState(reqDto.getAsyncExecuteState());//SimpleFieldAssign//sourceId:1037462_1
        }

        /*3-15-01修改执行进度[6960]   */
        Assert.isNull(omsExecuteProgress.getExecuteProgressId(), "D3重置执行进度(公共)-3-15-01修改执行进度-执行进度记录ID不能为空", false);
        bOOLEAN = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress)/*vcase invoke 本地 method 方法调用;*/;


        ResetExecuteProgressComRespDto retData = new ResetExecuteProgressComRespDto();


        return retData;
    }

    /**
     * D3重置执行进度处理[7210]
     * gen by moon at 6/20/2023, 1:51:18 AM
     */
    @Trace(operationName = "D3重置执行进度处理")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResetExecuteProgressDisposeRespDto resetExecuteProgressDispose(ResetExecuteProgressDisposeReqDto reqDto) {


        //步骤0: 3-15-01查执行进度详情 - queryExecuteProgressDetail
        OmsExecuteProgress omsExecuteProgress = null;
        QueryExecuteProgressDetailReq queryExecuteProgressDetailReq = new QueryExecuteProgressDetailReq();
        if (reqDto != null) {
            queryExecuteProgressDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1037634_1
            queryExecuteProgressDetailReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1037635_1
            queryExecuteProgressDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1037636_1
        }

        /*3-15-01查执行进度详情[6959]   */
        Assert.isNull(queryExecuteProgressDetailReq.getObjectId(), "D3重置执行进度处理-3-15-01查执行进度详情-归属对象内容ID不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getUseTypeCode(), "D3重置执行进度处理-3-15-01查执行进度详情-用途类型编码不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getThemeContentId(), "D3重置执行进度处理-3-15-01查执行进度详情-主题内容ID不能为空", false);
        omsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-15-01修改执行进度 - updateExecuteProgress
        boolean bOOLEAN;
        if (omsExecuteProgress != null) {
            OmsExecuteProgress omsExecuteProgress_2 = new OmsExecuteProgress();
            omsExecuteProgress_2.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1037647_1
            omsExecuteProgress_2.setIsComplete("FALSE");//sourceId:1037648_1
            omsExecuteProgress_2.setAsyncExecuteState("NOT_START");//sourceId:1037649_1
            if (omsExecuteProgress != null) {
                omsExecuteProgress_2.setExecuteProgressId(omsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:1037646_1
            }

            /*3-15-01重置执行进度[6960]   */
            Assert.isNull(omsExecuteProgress_2.getExecuteProgressId(), "D3重置执行进度处理-3-15-01重置执行进度-执行进度记录ID不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getExecuteProgressValue(), "D3重置执行进度处理-3-15-01重置执行进度-执行进度值不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getIsComplete(), "D3重置执行进度处理-3-15-01重置执行进度-是否已完成不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getAsyncExecuteState(), "D3重置执行进度处理-3-15-01重置执行进度-异步执行状态不能为空", false);
            bOOLEAN = mOmsExecuteProgressService.updateExecuteProgress(omsExecuteProgress_2)/*vcase invoke 本地 method 方法调用;*/;


        }

        ResetExecuteProgressDisposeRespDto retData = new ResetExecuteProgressDisposeRespDto();


        return retData;
    }

    /**
     * D3获取执行进度信息(公共)[7207]
     * gen by moon at 6/22/2023, 1:14:36 AM
     */
    @Trace(operationName = "D3获取执行进度信息(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainStatisticsUpdateExecuteProgressComRespDto obtainStatisticsUpdateExecuteProgressCom(ObtainStatisticsUpdateExecuteProgressComReqDto reqDto) {


        ImplementGainInParameterFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage 3-15-01查执行进度详情  45545
        OmsExecuteProgress omsExecuteProgress = null;
        QueryExecuteProgressDetailReq queryExecuteProgressDetailReq = new QueryExecuteProgressDetailReq();
        if (reqDto != null) {
            queryExecuteProgressDetailReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1042317_1_45545
            queryExecuteProgressDetailReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1042306_1_45545
            queryExecuteProgressDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042307_1_45545
        }

        /*3-15-01查执行进度详情[6959]   */
        Assert.isNull(queryExecuteProgressDetailReq.getObjectId(), "D3获取执行进度信息(公共)-3-15-01查执行进度详情-归属对象内容ID不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getUseTypeCode(), "D3获取执行进度信息(公共)-3-15-01查执行进度详情-用途类型编码不能为空", false);
        Assert.isNull(queryExecuteProgressDetailReq.getThemeContentId(), "D3获取执行进度信息(公共)-3-15-01查执行进度详情-主题内容ID不能为空", false);
        omsExecuteProgress = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsExecuteProgress == null)) {
            //if(3-15-01查执行进度详情.出参 值等于空 )  45546

            String string = null;
            OmsExecuteProgress omsExecuteProgress_2 = new OmsExecuteProgress();
            omsExecuteProgress_2.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1042327_1_45547
            omsExecuteProgress_2.setIsComplete("FALSE");//sourceId:1042321_1_45547
            omsExecuteProgress_2.setAsyncExecuteState("NOT_START");//sourceId:1042333_1_45547
            if (reqDto != null) {
                omsExecuteProgress_2.setObjectTypeCode(reqDto.getObjectTypeCode());//SimpleFieldAssign//sourceId:1042328_1_45547
                omsExecuteProgress_2.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1042329_1_45547
                omsExecuteProgress_2.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1042322_1_45547
                omsExecuteProgress_2.setThemeContentTypeCode(reqDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1042330_1_45547
                omsExecuteProgress_2.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042331_1_45547
                omsExecuteProgress_2.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1042323_1_45547
                omsExecuteProgress_2.setCreateInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1042324_1_45547
                omsExecuteProgress_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1042325_1_45547
                omsExecuteProgress_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:1042326_1_45547
            }

            /*3-15-01新增执行进度[6958]   */
            Assert.isNull(omsExecuteProgress_2.getExecuteProgressValue(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-执行进度值不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getIsComplete(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-是否已完成不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getAsyncExecuteState(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-异步执行状态不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getObjectTypeCode(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-归属对象类型编码不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getObjectId(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-归属对象内容ID不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getUseTypeCode(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-用途类型编码不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getThemeContentTypeCode(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-主题内容类型编码不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getThemeContentId(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-主题内容ID不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getOperationInductionId(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-操作人就职记录ID不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getCreateInductionId(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-创建人就职记录ID不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getSpaceId(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-创建于空间ID不能为空", false);
            Assert.isNull(omsExecuteProgress_2.getAppId(), "D3获取执行进度信息(公共)-3-15-01新增执行进度-创建于联盟应用ID不能为空", false);
            string = mOmsExecuteProgressService.addExecuteProgress(omsExecuteProgress_2)/*vcase invoke 本地 method 方法调用;*/;


            OmsExecuteProgress omsExecuteProgress_3 = null;
            if (string != null) {
                QueryExecuteProgressDetailReq queryExecuteProgressDetailReq_1 = new QueryExecuteProgressDetailReq();
                if (string != null) {
                    queryExecuteProgressDetailReq_1.setExecuteProgressId(string);//SimpleFieldAssign//sourceId:1049296_1_45848
                }

                /*3-15-01查新增的执行进度[6959]   */
                Assert.isNull(queryExecuteProgressDetailReq_1.getExecuteProgressId(), "D3获取执行进度信息(公共)-3-15-01查新增的执行进度-执行进度记录ID不能为空", false);
                omsExecuteProgress_3 = mOmsExecuteProgressService.queryExecuteProgressDetail(queryExecuteProgressDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
            if (omsExecuteProgress_3 != null) {
                ImplementGainInParameterFieldsReqDto receptionServiceReq = new ImplementGainInParameterFieldsReqDto();
                if (omsExecuteProgress_3 != null) {
                    receptionServiceReq.setExecuteProgressId(omsExecuteProgress_3.getExecuteProgressId());//SimpleFieldAssign//sourceId:1042700_1_45552
                    receptionServiceReq.setAsyncExecuteState(omsExecuteProgress_3.getAsyncExecuteState());//SimpleFieldAssign//sourceId:1042701_1_45552
                }

                /*M3接收上文出参字段[6965]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getExecuteProgressId(), "D3获取执行进度信息(公共)-M3接收上文出参字段-执行进度记录ID不能为空", false);
                Assert.isNull(receptionServiceReq.getAsyncExecuteState(), "D3获取执行进度信息(公共)-M3接收上文出参字段-异步执行状态不能为空", false);
                receptionServiceRes = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else {
            //else  45550

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes_2 = null;
            if (omsExecuteProgress != null) {
                ImplementGainInParameterFieldsReqDto receptionServiceReq_1 = new ImplementGainInParameterFieldsReqDto();
                if (omsExecuteProgress != null) {
                    receptionServiceReq_1.setExecuteProgressId(omsExecuteProgress.getExecuteProgressId());//SimpleFieldAssign//sourceId:1042700_1_45551
                    receptionServiceReq_1.setAsyncExecuteState(omsExecuteProgress.getAsyncExecuteState());//SimpleFieldAssign//sourceId:1042701_1_45551
                }

                /*M3接收上文出参字段[6965]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getExecuteProgressId(), "D3获取执行进度信息(公共)-M3接收上文出参字段-执行进度记录ID不能为空", false);
                Assert.isNull(receptionServiceReq_1.getAsyncExecuteState(), "D3获取执行进度信息(公共)-M3接收上文出参字段-异步执行状态不能为空", false);
                receptionServiceRes_2 = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        ObtainStatisticsUpdateExecuteProgressComRespDto retData = new ObtainStatisticsUpdateExecuteProgressComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setExecuteProgressId(receptionServiceRes_1.getExecuteProgressId());//SimpleFieldAssign//sourceId:1042706_1
            retData.setAsyncExecuteState(receptionServiceRes_1.getAsyncExecuteState());//SimpleFieldAssign//sourceId:1042707_1
        }


        return retData;
    }

    /**
     * D3执行进度运行判断(公共)[7243]
     * gen by moon at 5/26/2024, 11:08:04 PM
     */
    @Trace(operationName = "D3执行进度运行判断(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementExecuteProgressOperationJudgeComRespDto implementExecuteProgressOperationJudgeCom(ImplementExecuteProgressOperationJudgeComReqDto reqDto) {


        ImplementGainInParameterFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage M3查缓存进度上锁状态  47331
        //ModelCode: queryCacheProgress
        ImplementQueryCacheProgressRespDto queryCacheProgressRes = null;
        ImplementQueryCacheProgressReqDto queryCacheProgressReq = new ImplementQueryCacheProgressReqDto();
        if (reqDto != null) {
            queryCacheProgressReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819352_1_47331
            queryCacheProgressReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1081406_1_47331
            queryCacheProgressReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081407_1_47331
            queryCacheProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1081408_1_47331
            queryCacheProgressReq.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1819353_1_47331
        }

        /*M3查缓存进度上锁状态[7290]  用于查缓存进度值 */
        Assert.isNull(queryCacheProgressReq.getObjectId(), "D3执行进度运行判断(公共)-M3查缓存进度上锁状态-归属对象内容ID不能为空", false);
        Assert.isNull(queryCacheProgressReq.getUseTypeCode(), "D3执行进度运行判断(公共)-M3查缓存进度上锁状态-用途类型编码不能为空", false);
        Assert.isNull(queryCacheProgressReq.getThemeContentId(), "D3执行进度运行判断(公共)-M3查缓存进度上锁状态-主题内容ID不能为空", false);
        queryCacheProgressRes = nbExecuteProgress.implementQueryCacheProgress(queryCacheProgressReq);


        if ((queryCacheProgressRes != null && queryCacheProgressRes.getLockState() != null && queryCacheProgressRes.getLockState().equals("LOCKING"))) {
            //if(M3查缓存进度上锁状态.上锁状态 等于 锁定中)  46185

//ModelCode: receptionService
            ImplementGainInParameterFieldsRespDto receptionServiceRes = null;
            ImplementGainInParameterFieldsReqDto receptionServiceReq = new ImplementGainInParameterFieldsReqDto();
            receptionServiceReq.setCustomField("操作过于频繁，请稍后再试~");//CUSTOM_CONVENTION//sourceId:1060139_1_46186

            /*M3执行进度异步运行状态文案故事[6965]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getCustomField(), "D3执行进度运行判断(公共)-M3执行进度异步运行状态文案故事-自定义字段不能为空", false);
            receptionServiceRes = nbExecuteProgress.implementGainInParameterFields(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        }
        ImplementExecuteProgressOperationJudgeComRespDto retData = new ImplementExecuteProgressOperationJudgeComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:1060140_1
        }


        return retData;
    }

    /**
     * D3-重置执行进度处理(公共)[7210]
     * gen by moon at 5/26/2024, 11:07:57 PM
     */
    @Trace(operationName = "D3-重置执行进度处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ResetExecuteProgressDisposeComRespDto resetExecuteProgressDisposeCom(ResetExecuteProgressDisposeComReqDto reqDto) {


        //步骤0: M3执行清除缓存进度值（特殊方法） - implementClearCacheProgress
        //ModelCode: clearCacheProgress
        ImplementClearCacheProgressRespDto clearCacheProgressRes = null;
        ImplementClearCacheProgressReqDto clearCacheProgressReq = new ImplementClearCacheProgressReqDto();
        if (reqDto != null) {
            clearCacheProgressReq.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1819348_1
            clearCacheProgressReq.setObjectId(reqDto.getObjectId());//SimpleFieldAssign//sourceId:1080363_1
            clearCacheProgressReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1080364_1
            clearCacheProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1080365_1
            clearCacheProgressReq.setOperationInductionId(reqDto.getOperationInductionId());//SimpleFieldAssign//sourceId:1819346_1
        }

        /*M3执行清除缓存进度值（特殊方法）[7291]  用于清除缓存进度值 */
        Assert.isNull(clearCacheProgressReq.getObjectId(), "D3-重置执行进度处理(公共)-M3执行清除缓存进度值（特殊方法）-归属对象内容ID不能为空", false);
        Assert.isNull(clearCacheProgressReq.getUseTypeCode(), "D3-重置执行进度处理(公共)-M3执行清除缓存进度值（特殊方法）-用途类型编码不能为空", false);
        Assert.isNull(clearCacheProgressReq.getThemeContentId(), "D3-重置执行进度处理(公共)-M3执行清除缓存进度值（特殊方法）-主题内容ID不能为空", false);
        clearCacheProgressRes = nbExecuteProgress.implementClearCacheProgress(clearCacheProgressReq);


        ResetExecuteProgressDisposeComRespDto retData = new ResetExecuteProgressDisposeComRespDto();


        return retData;
    }

    /**
     * 11111D3撤销修订执行进度处理(公共)[7058]
     * gen by moon at 6/8/2024, 3:41:00 AM
     */
    @Trace(operationName = "11111D3撤销修订执行进度处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UndoReviseExecuteProgressDisposeComRespDto undoReviseExecuteProgressDisposeCom(UndoReviseExecuteProgressDisposeComReqDto reqDto) {


        //步骤0: 3-15-01批量查执行进度 - batchQueryExecuteProgress
        List<OmsExecuteProgress> listOmsExecuteProgress = new ArrayList<>();
        BatchQueryExecuteProgressReq batchQueryExecuteProgressReq = new BatchQueryExecuteProgressReq();
        if (reqDto != null) {
            batchQueryExecuteProgressReq.setProgressRecordList(reqDto.getExecuteProgressList());//list-field-assign//sourceId:998850_1
            batchQueryExecuteProgressReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:998852_1
        }

        /*3-15-01批量查执行进度[6962]   */

        listOmsExecuteProgress = mOmsExecuteProgressService.batchQueryExecuteProgress(batchQueryExecuteProgressReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-15-01批量删执行进度 - batchDeleteExecuteProgress
        boolean bOOLEAN;
        if (listOmsExecuteProgress != null && !CollectionUtil.isEmpty(listOmsExecuteProgress) && listOmsExecuteProgress.size() > 0) {
            List<String> listString = new ArrayList<>();
            if (listOmsExecuteProgress != null && !CollectionUtil.isEmpty(listOmsExecuteProgress) && listOmsExecuteProgress != null && !CollectionUtil.isEmpty(listOmsExecuteProgress)) {
                listString = listOmsExecuteProgress.stream().map(item -> item.getExecuteProgressId())
                        .collect(Collectors.toList());/*list-to-strings*///sourceId:998854_1
            }

            /*3-15-01批量删执行进度[6981]   */

            bOOLEAN = mOmsExecuteProgressService.batchDeleteExecuteProgress(listString)/*vcase invoke 本地 method 方法调用;*/;


        }

        UndoReviseExecuteProgressDisposeComRespDto retData = new UndoReviseExecuteProgressDisposeComRespDto();


        return retData;
    }
}
//

